home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / rhythmbox / plugins / artdisplay / AmazonCoverArtSearch.py < prev    next >
Encoding:
Python Source  |  2009-04-07  |  9.4 KB  |  294 lines
  1. # -*- Mode: python; coding: utf-8; tab-width: 8; indent-tabs-mode: t; -*- 
  2. #
  3. # Copyright (C) 2006 - Gareth Murphy, Martin Szulecki
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2, or (at your option)
  8. # any later version.
  9. #
  10. # The Rhythmbox authors hereby grant permission for non-GPL compatible
  11. # GStreamer plugins to be used and distributed together with GStreamer
  12. # and Rhythmbox. This permission is above and beyond the permissions granted
  13. # by the GPL license by which Rhythmbox is covered. If you modify this code
  14. # you may extend this exception to your version of the code, but you are not
  15. # obligated to do so. If you do not wish to do so, delete this exception
  16. # statement from your version.
  17. # 
  18. # This program is distributed in the hope that it will be useful,
  19. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21. # GNU General Public License for more details.
  22. #
  23. # You should have received a copy of the GNU General Public License
  24. # along with this program; if not, write to the Free Software
  25. # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
  26.  
  27. from xml.dom import minidom
  28. import re
  29. import locale
  30. import urllib
  31.  
  32. import rb
  33. import rhythmdb
  34.  
  35. LICENSE_KEY = "18C3VZN9HCECM5G3HQG2"
  36. DEFAULT_LOCALE = "en_US"
  37. ASSOCIATE = "webservices-20"
  38.  
  39. # We are not allowed to batch more than 2 requests at once
  40. # http://docs.amazonwebservices.com/AWSEcommerceService/4-0/PgCombiningOperations.html
  41. MAX_BATCH_JOBS = 2
  42.  
  43.  
  44. class Bag: pass
  45.  
  46. class AmazonCoverArtSearch (object):
  47.     def __init__ (self):
  48.         self.searching = False
  49.         self.cancel = False
  50.         self.db = None
  51.         self.entry = None
  52.         (self.tld, self.encoding) = self.__get_locale ()
  53.  
  54.     def __get_locale (self):
  55.         # "JP is the only locale that correctly takes UTF8 input. All other locales use LATIN1."
  56.         # http://developer.amazonwebservices.com/connect/entry.jspa?externalID=1295&categoryID=117
  57.         supported_locales = {
  58.             "en_US" : ("com", "latin1"),
  59.             "en_GB" : ("co.uk", "latin1"),
  60.             "de" : ("de", "latin1"),
  61.             "ja" : ("jp", "utf8")
  62.         }
  63.  
  64.         lc_id = DEFAULT_LOCALE
  65.         default = locale.getdefaultlocale ()[0]
  66.         if default:
  67.             if supported_locales.has_key (default):
  68.                 lc_id = default
  69.             else:
  70.                 lang = default.split("_")[0]
  71.                 if supported_locales.has_key (lang):
  72.                     lc_id = lang
  73.  
  74.         return supported_locales[lc_id]
  75.  
  76.     def search (self, db, entry, on_search_completed_callback, *args):
  77.         self.searching = True
  78.         self.cancel = False
  79.         self.db = db
  80.         self.entry = entry
  81.         self.on_search_completed_callback = on_search_completed_callback
  82.         self.args = args
  83.         self.keywords = []
  84.  
  85.         st_artist = db.entry_get (entry, rhythmdb.PROP_ARTIST) or _("Unknown")
  86.         st_album = db.entry_get (entry, rhythmdb.PROP_ALBUM) or _("Unknown")
  87.  
  88.         if st_artist == st_album == _("Unknown"):
  89.             self.on_search_completed (None)
  90.             return
  91.  
  92.         # Tidy up
  93.  
  94.         # Replace quote characters
  95.         # don't replace single quote: could be important punctuation
  96.         for char in ["\""]:
  97.             st_artist = st_artist.replace (char, '')
  98.             st_album = st_album.replace (char, '')
  99.  
  100.  
  101.         self.st_album = st_album
  102.         self.st_artist = st_artist
  103.  
  104.         # Remove variants of Disc/CD [1-9] from album title before search
  105.         for exp in ["\([Dd]isc *[1-9]+\)", "\([Cc][Dd] *[1-9]+\)"]:
  106.             p = re.compile (exp)
  107.             st_album = p.sub ('', st_album)
  108.  
  109.         st_album_no_vol = st_album
  110.         for exp in ["\(*[Vv]ol.*[1-9]+\)*"]:
  111.             p = re.compile (exp)
  112.             st_album_no_vol = p.sub ('', st_album_no_vol)
  113.  
  114.         self.st_album_no_vol = st_album_no_vol
  115.  
  116.         # Save current search's entry properties
  117.         self.search_album = st_album
  118.         self.search_artist = st_artist
  119.         self.search_album_no_vol = st_album_no_vol
  120.         
  121.         # TODO: Improve to decrease wrong cover downloads, maybe add severity?
  122.         # Assemble list of search keywords (and thus search queries)
  123.         if st_album == _("Unknown"):
  124.             self.keywords.append ("%s Best of" % (st_artist))
  125.             self.keywords.append ("%s Greatest Hits" % (st_artist))
  126.             self.keywords.append ("%s Essential" % (st_artist))
  127.             self.keywords.append ("%s Collection" % (st_artist))
  128.             self.keywords.append ("%s" % (st_artist))
  129.         elif st_artist == _("Unknown"):
  130.             self.keywords.append ("%s" % (st_album))
  131.             if st_album_no_vol != st_artist:
  132.                 self.keywords.append ("%s" % (st_album_no_vol))
  133.             self.keywords.append ("Various %s" % (st_album))
  134.         else:
  135.             if st_album != st_artist:
  136.                 self.keywords.append ("%s %s" % (st_artist, st_album))
  137.                 if st_album_no_vol != st_album:
  138.                     self.keywords.append ("%s %s" % (st_artist, st_album_no_vol))
  139.                 self.keywords.append ("Various %s" % (st_album))
  140.             self.keywords.append ("%s" % (st_artist))
  141.  
  142.         # Initiate asynchronous search
  143.         self.search_next ()
  144.  
  145.     def search_next (self):
  146.         if len (self.keywords) == 0:
  147.             # No keywords left to search -> no results
  148.             self.on_search_completed (None)
  149.             return False
  150.  
  151.         self.searching = True
  152.  
  153.         url = "http://ecs.amazonaws." + self.tld + "/onca/xml" \
  154.               "?Service=AWSECommerceService"                   \
  155.               "&AWSAccessKeyId=" + LICENSE_KEY +               \
  156.               "&AssociateTag=" + ASSOCIATE +                   \
  157.               "&ResponseGroup=Images,ItemAttributes"           \
  158.               "&Operation=ItemSearch"                          \
  159.               "&ItemSearch.Shared.SearchIndex=Music"
  160.  
  161.         job = 1
  162.         while job <= MAX_BATCH_JOBS and len (self.keywords) > 0:
  163.             keyword = self.keywords.pop (0)
  164.             keyword = keyword.encode (self.encoding, "ignore")
  165.             keyword = keyword.strip ()
  166.             keyword = urllib.quote (keyword)
  167.             url += "&ItemSearch.%d.Keywords=%s" % (job, keyword)
  168.             job += 1
  169.  
  170.         # Retrieve search for keyword
  171.         l = rb.Loader()
  172.         l.get_url (url, self.on_search_response)
  173.         return True
  174.  
  175.     def __unmarshal (self, element):
  176.         rc = Bag ()
  177.         child_elements = [e for e in element.childNodes if isinstance (e, minidom.Element)]
  178.         if child_elements:
  179.             for child in child_elements:
  180.                 key = child.tagName
  181.                 if hasattr (rc, key):
  182.                     if not isinstance (getattr (rc, key), list):
  183.                         setattr (rc, key, [getattr (rc, key)])
  184.                     getattr (rc, key).append (self.__unmarshal (child))
  185.                 # get_best_match_urls() wants a list, even if there is only one item/artist
  186.                 elif child.tagName in ("Items", "Item", "Artist"):
  187.                     setattr (rc, key, [self.__unmarshal(child)])
  188.                 else:
  189.                     setattr (rc, key, self.__unmarshal(child))
  190.         else:
  191.             rc = "".join ([e.data for e in element.childNodes if isinstance (e, minidom.Text)])
  192.         return rc
  193.  
  194.     def on_search_response (self, result_data):
  195.         if result_data is None:
  196.             self.search_next()
  197.             return
  198.  
  199.         try:
  200.             xmldoc = minidom.parseString (result_data)
  201.         except:
  202.             self.search_next()
  203.             return
  204.         
  205.         data = self.__unmarshal (xmldoc)
  206.         if not hasattr (data, "ItemSearchResponse") or \
  207.            not hasattr (data.ItemSearchResponse, "Items"):
  208.             # Something went wrong ...
  209.             self.search_next ()
  210.         else:
  211.             # We got some search results
  212.             self.on_search_results (data.ItemSearchResponse.Items)
  213.  
  214.     def on_search_results (self, results):
  215.         self.on_search_completed (results)
  216.  
  217.     def on_search_completed (self, result):
  218.         self.on_search_completed_callback (self, self.entry, result, *self.args)
  219.         self.searching = False
  220.  
  221.     def __tidy_up_string (self, s):
  222.         # Lowercase
  223.         s = s.lower ()
  224.         # Strip
  225.         s = s.strip ()
  226.  
  227.         # TODO: Convert accented to unaccented (fixes matching Salom√© vs Salome)
  228.         s = s.replace (" - ", " ")    
  229.         s = s.replace (": ", " ")
  230.         s = s.replace (" & ", " and ")
  231.  
  232.         return s
  233.  
  234.     def __valid_match (self, item):
  235.         return (hasattr (item, "LargeImage") or hasattr (item, "MediumImage")) \
  236.                and hasattr (item, "ItemAttributes")
  237.  
  238.     def get_best_match_urls (self, search_results):
  239.         # Default to "no match", our results must match our criteria
  240.         best_match = None
  241.  
  242.         for result in search_results:
  243.             if not hasattr (result, "Item"):
  244.                 # Search was unsuccessful, try next batch job
  245.                 continue
  246.  
  247.             items = filter(self.__valid_match, result.Item)
  248.             if self.search_album != _("Unknown"):
  249.                 album_check = self.__tidy_up_string (self.search_album)
  250.                 for item in items:
  251.                     if not hasattr (item.ItemAttributes, "Title"):
  252.                         continue
  253.  
  254.                     album = self.__tidy_up_string (item.ItemAttributes.Title)
  255.                     if album == album_check:
  256.                         # Found exact album, can not get better than that
  257.                         best_match = item
  258.                         break
  259.                     # If we already found a best_match, just keep checking for exact one
  260.                     # Check the results for both an album name that contains the name
  261.                     # we're searching for, and an album name that's a substring of the
  262.                     # name we're searching for
  263.                     elif (best_match is None) and \
  264.                          (album.find (album_check) != -1 or
  265.                           album_check.find (album) != -1):
  266.                         best_match = item
  267.  
  268.             # If we still have no definite hit, use first result where artist matches
  269.             if (self.search_album == _("Unknown") and self.search_artist != _("Unknown")):
  270.                 artist_check = self.__tidy_up_string (self.search_artist)
  271.                 if best_match is None:
  272.                     # Check if artist appears in the Artists list
  273.                     hit = False
  274.                     for item in items:
  275.                         if not hasattr (item.ItemAttributes, "Artist"):
  276.                             continue
  277.  
  278.                         for artist in item.ItemAttributes.Artist:
  279.                             artist = self.__tidy_up_string (artist)
  280.                             if artist.find (artist_check) != -1:
  281.                                 best_match = item
  282.                                 hit = True
  283.                                 break
  284.                         if hit:
  285.                             break
  286.  
  287.             urls = [getattr (best_match, size).URL for size in ("LargeImage", "MediumImage")
  288.                     if hasattr (best_match, size)]
  289.             if urls:
  290.                 return urls
  291.  
  292.         # No search was successful
  293.         return []
  294.